package com.sdses.weather.config.mapping;//package com.sdses.weather.service;
//
//import com.jayway.jsonpath.JsonPath;
//import com.jayway.jsonpath.ReadContext;
//import com.sdses.weather.config.WeatherProviderSchemaConfig;
//import com.sdses.weather.utils.SortHelper;
//import lombok.extern.slf4j.Slf4j;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.context.ApplicationContext;
//import org.springframework.stereotype.Component;
//
//import java.lang.reflect.Field;
//import java.util.*;
//import java.util.concurrent.ConcurrentHashMap;
//import java.util.concurrent.ConcurrentMap;
//import java.util.function.Function;
//import java.util.stream.Collectors;
//
//@Slf4j
//@Component
//public class WeatherMappingFiledNew {
//
//    // 字段缓存：Class -> fieldName -> Field
//    private final ConcurrentMap<Class<?>, ConcurrentMap<String, Field>> fieldCache = new ConcurrentHashMap<>();
//    @Autowired
//    private ApplicationContext applicationContext; // 用于获取 Converter Bean
//    @Autowired
//    private WeatherProviderSchemaConfig weatherProviderSchemaConfig;
//
//    // 静态 Map 初始化（JDK 8 风格）
//    private static final Map<String, Function<WeatherProviderSchemaConfig.ProviderConfig, WeatherProviderSchemaConfig.DataTypeConfig>> TYPE_GETTER_MAP
//            = new HashMap<>();
//
//    static {
//        TYPE_GETTER_MAP.put("condition", WeatherProviderSchemaConfig.ProviderConfig::getCondition);
//        TYPE_GETTER_MAP.put("hourly", WeatherProviderSchemaConfig.ProviderConfig::getHourly);
//        TYPE_GETTER_MAP.put("alert", WeatherProviderSchemaConfig.ProviderConfig::getAlert);
//        TYPE_GETTER_MAP.put("daily", WeatherProviderSchemaConfig.ProviderConfig::getDaily);
//    }
//
//    private WeatherProviderSchemaConfig.DataTypeConfig getDataTypeConfig(WeatherProviderSchemaConfig.ProviderConfig cfg, String type) {
//        if (type == null || cfg == null) {
//            return null;
//        }
//        Function<WeatherProviderSchemaConfig.ProviderConfig, WeatherProviderSchemaConfig.DataTypeConfig> getter = TYPE_GETTER_MAP.get(type);
//        return getter != null ? getter.apply(cfg) : null;
//    }
//
//    /**
//     * 主入口：将 JSON 映射为指定类型的对象列表
//     */
//    public <T> List<T> mapDataList(String json, String provider, String dataType, Class<T> targetType) {
//
//        WeatherProviderSchemaConfig.ProviderConfig providerCfg = Optional.ofNullable(weatherProviderSchemaConfig.getProviders())
//                .map(providers -> providers.get(provider))
//                .orElse(null);
//
//        if (providerCfg == null) {
//            log.warn("Unknown weather provider: {}", provider);
//            return Collections.emptyList();
//        }
//
//        WeatherProviderSchemaConfig.DataTypeConfig typeConfig = getDataTypeConfig(providerCfg, dataType);
//        if (typeConfig == null) {
//            log.warn("No config found for data type '{}' of provider '{}'", dataType, provider);
//            return Collections.emptyList();
//        }
//
//        List<Map<String, Object>> dataList = extractListWithFallbacks(json, providerCfg, typeConfig);
//        if (dataList.isEmpty()) {
//            log.debug("No data extracted for provider='{}', dataType='{}'", provider, dataType);
//            return Collections.emptyList();
//        }
//
//        List<T> result = dataList.stream()
//                .map(item -> mapItem(item, typeConfig.getFields(), targetType))
//                .filter(Objects::nonNull)
//                .collect(Collectors.toList());
//
//        result = SortHelper.sortByConfig(result, typeConfig.getFields());
//        return result;
//
//    }
//
//    // ----------------------- JSON 提取 -----------------------
//    private Map<String, Object> extractObject(String json, String jsonPath) {
//        if (isBlank(json) || isBlank(jsonPath)) {
//            return null;
//        }
//
//        try {
//            ReadContext context = JsonPath.parse(json);
//            Object obj = context.read(jsonPath);
//
//            if (obj == null) {
//                return null;
//            }
//
//            // 1. 如果是 Map，尝试安全转换
//            if (obj instanceof Map) {
//                return castToMap((Map<?, ?>) obj);
//            }
//
//            // 2. 如果是 List，取第一个 Map 类型的元素
//            if (obj instanceof List) {
//                List<?> list = (List<?>) obj;
//                for (Object item : list) {
//                    if (item instanceof Map) {
//                        return castToMap((Map<?, ?>) item);
//                    }
//                }
//                return null; // List 中没有 Map
//            }
//
//            // 3. 基本类型，包装
//            return Collections.singletonMap("value", obj);
//
//        } catch (Exception e) {
//            log.error("JSONPath extractObject failed for path: {}", jsonPath, e);
//            return null;
//        }
//    }
//
//    /**
//     * 安全类型转换：Object -> Map<String, Object>
//     */
//    @SuppressWarnings("unchecked")
//    private Map<String, Object> castToMap(Map<?, ?> map) {
//        if (map == null) return null;
//        if (map.isEmpty()) return (Map<String, Object>) map;
//        if (map.keySet().iterator().next() instanceof String) {
//            return (Map<String, Object>) map;
//        }
//        return null;
//    }
//
//    // ----------------------- 路径处理 -----------------------
//
//    private String resolvePlaceholders(String path, WeatherProviderSchemaConfig.ProviderConfig config) {
//        if (isBlank(path) || config == null) return path;
//
//        String result = path;
//        if (result.contains("${basePath}")) {
//            result = result.replace("${basePath}", config.getBasePath());
//        }
//        // 可扩展其他变量：${root}, ${data} 等
//        return result;
//    }
//
//    // ----------------------- 映射逻辑 -----------------------
//
//    private <T> T mapItem(Map<String, Object> source,
//                          List<WeatherProviderSchemaConfig.FieldMapping> fields,
//                          Class<T> targetType) {
//        if (source == null || fields == null || fields.isEmpty()) return null;
//
//        try {
//            T instance = targetType.getDeclaredConstructor().newInstance();
//
//            for (WeatherProviderSchemaConfig.FieldMapping field : fields) {
//                String jsonKey = field.getJson();
//                Object value = source.get(jsonKey);
//                // 🔧 如果 java 未配置，默认等于 json
//                String javaKey = field.getJava() != null ? field.getJava() : jsonKey;
//                if (value == null) continue;
//
//                Field javaField = findField(targetType, javaKey);
//                if (javaField == null) continue;
//
//                Object convertedValue = convertValue(value, field, javaField.getType());
//                if (convertedValue != null) {
//                    setFieldValue(instance, javaField, convertedValue);
//                }
//            }
//
//            return instance;
//
//        } catch (Exception e) {
//            log.error("Failed to map item to type: {}", targetType.getSimpleName(), e);
//            return null;
//        }
//    }
//
//    // ----------------------- 反射工具 -----------------------
//
//    private Field findField(Class<?> clazz, String fieldName) {
//        return fieldCache
//                .computeIfAbsent(clazz, k -> new ConcurrentHashMap<>())
//                .computeIfAbsent(fieldName, name -> {
//                    try {
//                        Field field = clazz.getDeclaredField(name);
//                        field.setAccessible(true);
//                        return field;
//                    } catch (NoSuchFieldException e) {
//                        log.warn("Field not found: {}.{}", clazz.getSimpleName(), name);
//                        return null;
//                    }
//                });
//    }
//
//    private void setFieldValue(Object instance, Field field, Object value) {
//        try {
//            field.setAccessible(true);
//            field.set(instance, value);
//        } catch (Exception e) {
//            log.error("Failed to set field value: {}.{} = {}", instance.getClass().getSimpleName(), field.getName(), value, e);
//        }
//    }
//
//    // ----------------------- 工具方法 -----------------------
//
//    private boolean isBlank(String str) {
//        return str == null || str.trim().isEmpty();
//    }
//
//
//    // 类型转换核心逻辑
//    private Object convertValue(Object value, WeatherProviderSchemaConfig.FieldMapping field, Class<?> targetType) {
//        if (value == null) return null;
//
//        // 1. 优先使用自定义 Converter
//        if (field.getConverter() != null && !field.getConverter().trim().isEmpty()) {
//            try {
//                Object converterBean = applicationContext.getBean(field.getConverter());
//                if (converterBean instanceof FieldConverter) {
//                    return ((FieldConverter<?>) converterBean).convert(value);
//                }
//            } catch (Exception e) {
//                log.error("类型转换 convertValue:{}", field.getConverter(), e);
//            }
//        }
//
//        // 2. 默认类型转换
//        String type = field.getType();
//        try {
//            if ("string".equalsIgnoreCase(type)) {
//                return value.toString();
//            } else if ("int".equalsIgnoreCase(type) || "integer".equalsIgnoreCase(type)) {
//                return Integer.valueOf(value.toString());
//            } else if ("long".equalsIgnoreCase(type)) {
//                return Long.valueOf(value.toString());
//            } else if ("double".equalsIgnoreCase(type)) {
//                return Double.valueOf(value.toString());
//            } else if ("boolean".equalsIgnoreCase(type)) {
//                return Boolean.valueOf(value.toString());
//            } else if ("enum".equalsIgnoreCase(type)) {
//                // enum 类型应由 Converter 处理，这里返回 null 提醒
//                return null;
//            } else if ("date".equalsIgnoreCase(type)) {
//                // TODO: 支持时间格式配置
//                return new Date(); // 简化示例
//            } else {
//                return value; // 原样返回
//            }
//        } catch (Exception e) {
//            log.error("类型转换 {}", type, e);
//            return null;
//        }
//    }
//
//    private List<Map<String, Object>> extractListWithFallbacks(
//            String json,
//            WeatherProviderSchemaConfig.ProviderConfig providerCfg,
//            WeatherProviderSchemaConfig.DataTypeConfig typeConfig) {
//
//        if (isBlank(json) || typeConfig.getArrayPaths().isEmpty()) {
//            return Collections.emptyList();
//        }
//
//
//
//        // 如果是单个对象路径，直接提取
//        if (!typeConfig.isArrayFlag()) {
//            String singlePath = typeConfig.getArrayPaths().get(0); // fallback 到第一个
//            if (isBlank(singlePath)) return Collections.emptyList();
//
//            String resolvedPath = resolvePlaceholders(singlePath, providerCfg);
//            Map<String, Object> obj = extractObject(json, resolvedPath);
//            return obj != null ? Collections.singletonList(obj) : Collections.emptyList();
//        }
//
//        // 多路径 fallback 模式
//        for (String pathTemplate : typeConfig.getArrayPaths()) {
//            String resolvedPath = resolvePlaceholders(pathTemplate, providerCfg);
//            if (isBlank(resolvedPath)) continue;
//
//            try {
//                ReadContext context = JsonPath.parse(json);
//                Object obj = context.read(resolvedPath);
//
//                if (obj != null) {
//                    List<Map<String, Object>> result = convertToList(obj);
//                    if (!result.isEmpty()) {
//                        log.debug("Success with JSONPath: {}", resolvedPath);
//                        return result;
//                    }
//                }
//            } catch (Exception e) {
//                log.trace("JSONPath '{}' failed: {}", resolvedPath, e.getMessage());
//                // 继续尝试下一个
//            }
//        }
//
//        log.debug("All JSONPath fallbacks failed for provider={}, type={}", providerCfg, typeConfig);
//        return Collections.emptyList();
//    }
//
//    private List<Map<String, Object>> convertToList(Object obj) {
//        if (obj == null) return Collections.emptyList();
//
//        if (obj instanceof List) {
//            List<?> list = (List<?>) obj;
//            List<Map<String, Object>> result = new ArrayList<>(list.size());
//            for (Object item : list) {
//                if (item instanceof Map) {
//                    Map<String, Object> map = castToMap((Map<?, ?>) item);
//                    if (map != null) {
//                        result.add(map);
//                    }
//                }
//            }
//            return result;
//        } else if (obj instanceof Map) {
//            Map<String, Object> map = castToMap((Map<?, ?>) obj);
//            return map != null ? Collections.singletonList(map) : Collections.emptyList();
//        } else {
//            return Collections.singletonList(Collections.singletonMap("value", obj));
//        }
//    }
//}
